from flask import Blueprint, render_template, request, jsonify, current_app
import os,datetime
from applications.common import curd
from applications.common.helper import ModelFilter
from applications.common.utils.http import table_api, success_api, fail_api
from applications.common.utils.rights import authorize
from applications.common.utils.validate import str_escape
from applications.extensions import db
from applications.models import ToolsType,ToolsData
from applications.schemas import DictTypeOutSchema, DictDataOutSchema,ReportDataOutSchema
from applications.common.utils import upload as upload_curd
bp = Blueprint('tools', __name__, url_prefix='/tools')


# 数据字典
@bp.get('/')
@authorize("system:tools:main")
def main():
    return render_template('system/tools/main.html')


@bp.get('/dictType/data')
@authorize("system:tools:main")
def dict_type_data():
    # 获取请求参数
    type_name = str_escape(request.args.get('typeName', type=str))
    # 查询参数构造
    mf = ModelFilter()
    if type_name:
        mf.vague(field_name="type_name", value=type_name)
    # orm查询
    # 使用分页获取data需要.items
    dict_all = ToolsType.query.filter(mf.get_filter(ToolsType)).layui_paginate()
    count = dict_all.total
    data = curd.model_to_dicts(schema=DictTypeOutSchema, data=dict_all.items)
    return table_api(data=data, count=count)


@bp.get('/dictType/add')
@authorize("system:tools:add", log=False)
def dict_type_add():
    return render_template('system/tools/add.html')


@bp.post('/dictType/save')
@authorize("system:tools:add", log=True)
def dict_type_save():
    req_json = request.get_json(force=True)
    description = str_escape(req_json.get("description"))
    enable = str_escape(req_json.get("enable"))
    type_code = str_escape(req_json.get("typeCode"))
    type_name = str_escape(req_json.get("typeName"))
    d = ToolsType(type_name=type_name, type_code=type_code, enable=enable, description=description)
    db.session.add(d)
    try:
        db.session.commit()
        if d.id is None:
            return fail_api(msg="增加失败")
        return success_api(msg="增加成功")
    except Exception as e:
        print(e)
        return fail_api(msg=f"增加失败,数据库错误,请检查日志")



#  编辑字典类型
@bp.get('/dictType/edit')
@authorize("system:tools:edit", log=True)
def dict_type_edit():
    _id = request.args.get('dictTypeId', type=int)
    dict_type = ToolsType.query.filter_by(id=_id).first()
    return render_template('system/tools/edit.html', dict_type=dict_type)


#  编辑字典类型
@bp.put('/dictType/update')
@authorize("system:tools:edit", log=True)
def dict_type_update():
    req_json = request.get_json(force=True)
    id = str_escape(req_json.get("id"))
    description = str_escape(req_json.get("description"))
    enable = str_escape(req_json.get("enable"))
    type_code = str_escape(req_json.get("typeCode"))
    type_name = str_escape(req_json.get("typeName"))
    ToolsType.query.filter_by(id=id).update({
        "description": description,
        "enable": enable,
        "type_code": type_code,
        "type_name": type_name
    })
    try:
        db.session.commit()
        return success_api(msg="更新成功")
    except Exception as e:
        print(e)
        return fail_api(msg=f"更新失败,数据库错误,请检查日志")


# 启用字典
@bp.put('/dictType/enable')
@authorize("system:tools:edit", log=True)
def dict_type_enable():
    _id = request.get_json(force=True).get('id')
    if id:
        res = curd.enable_status(ToolsType,_id)
        if not res:
            return fail_api(msg="出错啦")
        return success_api("启动成功")
    return fail_api(msg="数据错误")


# 禁用字典
@bp.put('/dictType/disable')
@authorize("system:tools:edit", log=True)
def dict_type_dis_enable():
    _id = request.get_json(force=True).get('id')
    if id:
        res = curd.disable_status(ToolsType,_id)
        if not res:
            return fail_api(msg="出错啦")
        return success_api("禁用成功")
    return fail_api(msg="数据错误")


# 删除字典类型
@bp.delete('/dictType/remove/<int:_id>')
@authorize("system:tools:remove", log=True)
def dict_type_delete(_id):
    '''也要删除文件'''
    r_type = ToolsType.query.filter_by(id=_id)
    type_code=r_type.first().type_code
    upload_url=current_app.config.get("UPLOADED_TOOLS_DEST")
    items=ToolsData.query.filter_by(type_code=type_code)
    for item in items:
        filename = item.data_label
        file_path = os.path.join(upload_url, filename)
        try:
            os.remove(file_path)
        except Exception as e:
            print(e)
            return fail_api(msg=f"删除失败:{e}")
    items.delete()
    # d=ReportData.query.filter_by(type_code=type_code).delete()
    r_type.delete()
    try:
        db.session.commit()
        return success_api(msg="删除成功")
    except Exception as e:
        print(e)
        return fail_api(msg="删除失败")


@bp.get('/dictData/data')
@authorize("system:tools:main", log=True)
def dict_code_data():
    type_code = str_escape(request.args.get('typeCode', type=str))
    dict_data = ToolsData.query.filter_by(type_code=type_code).layui_paginate()
    count = dict_data.total
    data = curd.model_to_dicts(schema=ReportDataOutSchema, data=dict_data.items)
    return table_api(data=data, count=count)


# 增加字典数据
@bp.get('/dictData/add')
@authorize("system:tools:add", log=True)
def dict_data_add():
    type_code = request.args.get('typeCode', type=str)
    return render_template('system/tools/data/add.html', type_code=type_code)

#   上传接口
@bp.post('/upload')
@authorize("system:tools:add", log=True)
def upload_api():
    if 'file' in request.files:
        report = request.files['file']
        mime = request.files['file'].content_type
        upload_url = current_app.config.get("UPLOADED_TOOLS_DEST")

        file_url,filename = upload_curd.upload_tools_one(report=report, mime=mime)
        size = os.path.getsize(upload_url + '/' + filename)
        res = {
            "msg": "上传成功",
            "code": 0,
            "success": True,
            "data":
                {"src": file_url,'mime':mime,'size':size,'filename':filename}
        }
        return jsonify(res)
    return fail_api()
# 增加字典数据
@bp.post('/dictData/save')
@authorize("system:tools:add", log=True)
def dict_data_save():
    req_json = request.get_json(force=True)


    href= str_escape(req_json.get("fileInfo").get('data').get('src'))
    data_label=str_escape(req_json.get("fileInfo").get('data').get('filename'))
    mime=str_escape(req_json.get("fileInfo").get('data').get('mime'))
    size = str_escape(req_json.get("fileInfo").get('data').get('size'))
    data_value = str_escape(req_json.get("dataValue"))

    enable = str_escape(req_json.get("enable"))
    remark = str_escape(req_json.get("remark"))
    type_code = str_escape(req_json.get("typeCode"))
    d = ToolsData(data_label=data_label,
                   data_value=data_value,
                   enable=enable,

                   remark=remark,
                   type_code=type_code,
                   href=href,
                   mime=mime,
                   size=size )

    try:
        db.session.add(d)
        db.session.commit()
        return success_api('增加成功')
    except Exception as e:
        print(e)
        return fail_api()





#  编辑字典数据
@bp.get('/dictData/edit')
@authorize("system:tools:edit", log=True)
def dict_data_edit():
    _id = request.args.get('dataId', type=str)
    dict_data = curd.get_one_by_id(ToolsData, _id)
    return render_template('system/tools/data/edit.html', dict_data=dict_data)


#  编辑字典数据
@bp.put('/dictData/update')
@authorize("system:tools:edit", log=True)
def dict_data_update():
    req_json = request.get_json(force=True)
    id = req_json.get("dataId")
    ToolsData.query.filter_by(id=id).update({

        "data_value": str_escape(req_json.get("dataValue")),
        "enable": str_escape(req_json.get("enable")),

        "remark": str_escape(req_json.get("remark")),
        "type_code": str_escape(req_json.get("typeCode"))

    })
    try:
        db.session.commit()
        return success_api(msg="更新成功")
    except Exception as e:
        return fail_api(msg="更新失败")


# 启用字典数据
@bp.put('/dictData/enable')
@authorize("system:tools:edit", log=True)
def dict_data_enable():
    _id = request.get_json(force=True).get('dataId')
    if _id:
        res = curd.enable_status(model=ToolsData, id=_id)
        if not res:
            return fail_api(msg="出错啦")
        return success_api(msg="启动成功")
    return fail_api(msg="数据错误")


# 禁用字典数据
@bp.put('/dictData/disable')
@authorize("system:tools:edit", log=True)
def dict_data_disenable():
    _id = request.get_json(force=True).get('dataId')
    if _id:
        res = curd.disable_status(model=ToolsData, id=_id)
        if not res:
            return fail_api(msg="出错啦")
        return success_api(msg="禁用成功")
    return fail_api(msg="数据错误")



# 删除字典类型
@bp.delete('dictData/remove/<int:id>')
@authorize("system:tools:remove", log=True)
def dict_data_delete(id):
    '''也要删除文件'''
    upload_url = current_app.config.get("UPLOADED_TOOLS_DEST")
    # res = curd.delete_one_by_id(model=ReportData, id=id)
    res=ToolsData.query.filter_by(id=id).first()
    filename=res.data_label
    file_path=os.path.join(upload_url,filename)
    try:
        os.remove(file_path)
    except Exception as e:
        print(e)

    res = curd.delete_one_by_id(model=ToolsData, id=id)
    if not res:
        return fail_api(msg="删除失败")
    return success_api(msg="删除成功")
